// 引入 react 依赖
import React, { Component } from 'react';
import { connect } from 'react-redux';
import { AsyncStorage, Platform } from 'react-native';
import Storage from 'react-native-storage';
var Dimensions = require('Dimensions');

// 引入第三方依赖
import * as WeChat from 'react-native-wechat';
import { CacheHelper } from "react-native-rn-cacheimage";
import { Actions } from 'react-native-router-flux';
import * as Routers from '../router/index.js'; //引入文件

// antd 按需加载
import { Portal, Toast } from '@ant-design/react-native';

// redux
import store from '../store/store'
import * as ActionTypes from '../constants/constants.js'


// request
import axios from 'axios'

// 接口前缀
// export const path = 'https://cheliang88.gicp.net'
export const path = 'https://dev.henghebooks.com.my'

export const apiPath = `${path}/bmall`
axios.defaults.baseURL = apiPath

// 微信支付使用
export const AppId = 'wx524a95e535397f6e'
export const secret = 'cb2680622f2a5674f57b414a7aed61db'

// 财付通商家id
export const payId = '1505615681'

// 商家id
export const shopnum = 'S160616155813'

export const longitude = 132.639308
export const latitude = 47.257497


export const ScreenWidth = Dimensions.get('window').width;
export const ScreenHeight = Dimensions.get('window').height;
export const ScreenScale = Dimensions.get('window').scale;

export const press = (fn) => {
    // requestAnimationFrame(() => {
    fn()
    // })
}

export const size = (number, type) => {
    if (type == 'interval') {
        return ScreenWidth - number - number
    }
    return (number / 750) * ScreenWidth
}

// 初始化 storage
export const storage = new Storage({
    // 最大容量，默认值1000条数据循环存储
    size: 9999999999999,

    // 存储引擎：对于RN使用AsyncStorage，对于web使用window.localStorage
    // 如果不指定则数据只会保存在内存中，重启后即丢失
    storageBackend: AsyncStorage,

    // 数据过期时间，默认一整天（1000 * 3600 * 24 毫秒），设为null则永不过期
    defaultExpires: null,

    // 读写时在内存中缓存数据。默认启用。
    enableCache: true,

    // 如果storage中没有相应数据，或数据已过期，
    // 则会调用相应的sync方法，无缝返回最新数据。
    // sync方法的具体说明会在后文提到
    // 你可以在构造函数这里就写好sync的方法
    // 或是在任何时候，直接对storage.sync进行赋值修改
    // 或是写到另一个文件里，这里require引入
    // sync: {
    //     // sync方法的名字必须和所存数据的key完全相同
    //     // 方法接受的参数为一整个object，所有参数从object中解构取出
    //     // 这里可以使用promise。或是使用普通回调函数，但需要调用resolve或reject。
    //     user(params) {
    //         let { user_no, resolve, reject, syncParams: { extraFetchOptions, someFlag } } = params;
    //         getUserInfo(user_no, (res) => {
    //             // 成功则调用resolve
    //             resolve && resolve(res);
    //         }, () => {
    //             // 失败则调用reject
    //             reject && reject(new Error('data parse error'));
    //         })
    //     }
    // }

})


// 清除图片缓存
export function clearCache() {
    CacheHelper.clearCache()
}

// 往 storage 中保存指定信息 
export function saveData(key, data) {
    storage.save({
        key: key,  // 注意:请不要在key中使用_下划线符号!
        data: data,
        // 如果不指定过期时间，则会使用defaultExpires参数
        // 如果设为null，则永不过期
        expires: null
    });
}

// 从 storage 中获取指定信息 
export function loadData(key, callback) {
    // 请求账户信息
    storage.load({
        key: key,
        // autoSync(默认为true)意味着在没有找到数据或数据过期时自动调用相应的sync方法
        autoSync: true,
        // syncInBackground(默认为true)意味着如果数据过期，
        // 在调用sync方法的同时先返回已经过期的数据。
        // 设置为false的话，则等待sync方法提供的最新数据(当然会需要更多时间)。
        syncInBackground: true,
    }).then((res) => {
        callback(res)
    }).catch((err) => {
        callback(null)
    })

}

// 从 storage 中删除指定信息 
export function removeData(key, callback) {
    // 请求账户信息
    storage.remove({
        key: key
    })
}



// 微信支付
export function wxPay(options) {
    return new Promise((resolve, reject) => {
        WeChat.isWXAppInstalled().then((isInstalled) => {
            if (isInstalled) {
                //发送授权请求
                WeChat.pay({
                    partnerid: payId,  // 商家向财付通申请的商家id
                    prepayid: options.package.slice(10, options.package.length),
                    package: 'Sign=WXPay',
                    noncestr: options.nonceStr,
                    timestamp: options.timeStamp - 0,
                    sign: options.paySign,
                }).then((success) => {
                    resolve(success)
                }).catch((error) => {
                    reject(error)
                })
            } else {
                Platform.OS == 'ios' ?
                    Alert.alert('没有安装微信', '是否安装微信？', [
                        { text: '取消' },
                        { text: '确定', onPress: () => { this.installWechat() } }
                    ]) :
                    Alert.alert('没有安装微信', '请先安装微信客户端在进行登录', [
                        { text: '确定' }
                    ])
            }
        }).catch((error) => {
            reject(error)
        })
    })

}

// 是否安装微信
export function isWXAppInstalled(options) {
    WeChat.isWXAppInstalled().then((isInstalled) => {
        if (isInstalled) {
            if (options.success) {
                options.success()
            }
        } else {
            Platform.OS == 'ios' ?
                Alert.alert('没有安装微信', '是否安装微信？', [
                    { text: '取消' },
                    { text: '确定', onPress: () => { this.installWechat() } }
                ]) :
                Alert.alert('没有安装微信', '请先安装微信客户端在进行登录', [
                    { text: '确定' }
                ])
            // Toast.hide();
        }
    }).catch((error) => {
        if (options.error) {
            options.error()
        }
    })
}

export const getStatusHeight = () => {
    let height = 0
    if (Platform.OS == 'ios') {
        height = 22
    }
    if (Platform.OS == 'ios' && ScreenWidth / ScreenHeight < 9 / 16) {
        height = 44
    }
    return height
}

export const getHeaderHeight = () => {
    let height = getStatusHeight() + 22
    return height
}

export const requestMessage = (res, loading, message) => {
    Portal.remove(loading)
    return new Promise((resolve, reject) => {
        if (res.error) {
            if (message) {
                Toast.fail(message.error, 1, null, false)
            }
            reject(res)
        } else {
            if (res.data) {
                if (res.data.code == 200 || res.data.code == 1000) {
                    if (message) {
                        Toast.success(message.success, 1, null, false)
                    }
                    resolve(res.data)
                } else {
                    if (message) {
                        Toast.fail(res.data.message, 1, null, false)
                    }
                    reject(res.data)
                }
            } else {
                if (message) {
                    Toast.fail(message.error, 1, null, false)
                }
                reject(res.data)
            }
        }
    })
}


export const requstPromise = (res) => {
    return new Promise((resolve, reject) => {
        console.log(res)
        if (res.status == 200) {
            resolve(res)
        } else {
            reject(res)
        }
    })
}


export const isLogin = (res) => {
    if (store.getState().auth.authorization) {
        return true
    } else {
        return false
    }
}


export const logout = (login) => {
    store.dispatch({
        type: ActionTypes.userInfoReset,
    })
    store.dispatch({
        type: ActionTypes.authReset,
    })
    removeData('userInfo')
    removeData('authorization')
    if (login) {
        // Toast.info('退出登录', 1, null, false)
        Actions.login()
    } else {

    }
}


export const ActionsRouter = (routerName, options) => {
    // let newName = Routers[attr].name[0].toLowerCase() + Routers[attr].name.split('').splice(1).join('')
    if (isLogin()) {
        Actions[routerName](options)
        return
    }
    let permissions = [
        { name: 'newProduct' },
        { name: 'shoppingCart' },
        { name: 'user' },
        { name: 'resetPassword' },
        { name: 'submitOrders' },
        { name: 'submitBook' },
        { name: 'submitMagazine' },
        { name: 'address' },
        { name: 'editAddress' },
        { name: 'userInfo' },
        { name: 'orderList' },
        { name: 'orderInfo' },
        { name: 'pay' },
        { name: 'payResults' },
    ]
    for (let i = 0; i < permissions.length; i++) {
        let item = permissions[i]
        if (item.name == routerName) {
            Actions.login()
            return
        }
    }
    Actions[routerName](options)
}

export const validation = {
    phone(value) {
        var reg = /^\d{9,11}$/
        return reg.test(value)
    },
    email(value) {
        var reg = /\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*/
        return reg.test(value)
    },
}
